package org.hujunfeng.http;

import java.io.*;
import java.util.HashMap;
import java.util.Map;

/**
 * 服务器的配置类
 */
public class Config {
    /**
    *  服务器的地址
    */
    private String host = "127.0.0.1";

    /**
     * 服务器默认对外提供服务的端口
     */
    private int serverPort = 8080;

    /**
     * 服务器对外监听关闭信号的端口
     */
    private int shutdownPort = 8088;

    /**
     * 连接超时时间
     */
    private long connectionTimeout = 2000;

    /**
     * 读取超时时间，单位是毫秒数
     */
    private int readTimeout = 2000;

    /**
     * 最大同时连接数
     */
    private int maxConnection = 150;

    /**
     * 核心线程数
     */
    private int coreThreads = 10;

    /**
     * 最大的线程数
     */
    private int maxThreads = 40;

    /**
     * 空闲线程休眠时间，单位是秒
     */
    private long freeTimeout = 60;

    /**
     * 最大的任务数
     */
    private int maxTasks = 200;

    public Config() {
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getServerPort() {
        return serverPort;
    }

    public void setServerPort(int serverPort) {
        this.serverPort = serverPort;
    }

    public int getShutdownPort() {
        return shutdownPort;
    }

    public void setShutdownPort(int shutdownPort) {
        this.shutdownPort = shutdownPort;
    }

    public long getConnectionTimeout() {
        return connectionTimeout;
    }

    public void setConnectionTimeout(long connectionTimeout) {
        this.connectionTimeout = connectionTimeout;
    }

    public int getReadTimeout() {
        return readTimeout;
    }

    public void setReadTimeout(int readTimeout) {
        this.readTimeout = readTimeout;
    }

    public int getMaxConnection() {
        return maxConnection;
    }

    public void setMaxConnection(int maxConnection) {
        this.maxConnection = maxConnection;
    }

    public int getCoreThreads() {
        return coreThreads;
    }

    public void setCoreThreads(int coreThreads) {
        this.coreThreads = coreThreads;
    }

    public int getMaxThreads() {
        return maxThreads;
    }

    public void setMaxThreads(int maxThreads) {
        this.maxThreads = maxThreads;
    }

    public long getFreeTimeout() {
        return freeTimeout;
    }

    public void setFreeTimeout(long freeTimeout) {
        this.freeTimeout = freeTimeout;
    }

    public int getMaxTasks() {
        return maxTasks;
    }

    public void setMaxTasks(int maxTasks) {
        this.maxTasks = maxTasks;
    }

    /**
     * 加载配置文件，生成配置对象
     * 是文本文件
     *
     * @param configPath 配置文件的路径
     * @param charset    配置文件的字符集
     */
    public void loadConfig(String configPath, String charset) {

        // 1、创建配置文件对象
        File configFile = new File(configPath);

        // 2、判断是不是存在
        if (!configFile.exists()) {
            try {
                throw new Exception("configPath is not exists.");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        // 3、判断是不是文件
        if (!configFile.isFile()) {
            try {
                throw new Exception("configPath is not a file.");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        // 4、定义缓冲字符阅读器
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(new File(configPath)), charset));

            // 5、存放配置的集合
            Map<String, String> map = new HashMap<>();

            // 6、每一行的中间变量
            String line = "";

            while (true) {
                // 7、读取一行
                line = reader.readLine();

                // 8、如果读取为空，跳出循环
                if (line == null) {
                    break;
                }

                // 9、去除左右两边的空格
                line = line.trim();

                // 10、判断处理
                // #开头的是注释
                // 空行也跳过这次处理
                if (line.startsWith("#") || line.equals("")) {
                    continue;
                } else {
                    // 用字符=来隔开。
                    String[] temp = line.split("=");

                    // 不为空，并且数组长度等于2
                    if (temp != null && temp.length == 2) {
                        String key = temp[0].trim();
                        String value = temp[1].trim();

                        // 11、放入map中
                        map.put(key, value);
                    }
                }
            }

            // 12、设置属性值
            setValue(map);

            // 13、关闭阅读器
            reader.close();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 处理Map中的参数，设置属性值
     *
     * @param map
     */
    private void setValue(Map<String, String> map) {
        // 如果不为空，就设置服务器地址属性
        if (notEmpty(map.get("host"))) {
            setHost(map.get("host"));
        }

        // 如果不为空，就设置服务器端口属性
        if (notEmpty(map.get("serverPort"))) {
            setServerPort(Integer.parseInt(map.get("serverPort")));
        }

        // 监听关闭信号的端口
        if (notEmpty(map.get("shutdownPort"))) {
            setShutdownPort(Integer.parseInt(map.get("shutdownPort")));
        }

        // 设置连接超时时间
        if (notEmpty(map.get("connectionTimeout"))) {
            setConnectionTimeout(Long.parseLong(map.get("connectionTimeout")));
        }

        // 设置读取超时时间
        if (notEmpty(map.get("readTimeout"))) {
            setReadTimeout(Integer.parseInt(map.get("readTimeout")));
        }

        // 设置最大的连接数
        if (notEmpty(map.get("maxConnection"))) {
            setMaxConnection(Integer.parseInt(map.get("maxConnection")));
        }

        // 设置核心线程数
        if (notEmpty(map.get("coreThreads"))) {
            setCoreThreads(Integer.parseInt(map.get("coreThreads")));
        }

        // 设置最大的线程数
        if (notEmpty(map.get("maxThreads"))) {
            setMaxThreads(Integer.parseInt(map.get("maxThreads")));
        }

        // 设置线程空闲时间
        if (notEmpty(map.get("freeTimeout"))) {
            setFreeTimeout(Long.parseLong(map.get("freeTimeout")));
        }

        // 设置最大任务数
        if (notEmpty(map.get("maxTasks"))) {
            setMaxTasks(Integer.parseInt(map.get("maxTasks")));
        }

    }

    /**
     * 测试属性值不为空
     *
     * @param value
     * @return
     */
    private boolean notEmpty(String value) {
        if (value != null && !value.equals("")) {
            return true;
        }
        return false;
    }

    @Override
    public String toString() {
        return "Config{" +
                "serverPort=" + serverPort +
                ", shutdownPort=" + shutdownPort +
                ", connectionTimeout=" + connectionTimeout +
                ", readTimeout=" + readTimeout +
                ", maxConnection=" + maxConnection +
                ", coreThreads=" + coreThreads +
                ", maxThreads=" + maxThreads +
                ", freeTimeout=" + freeTimeout +
                ", maxTasks=" + maxTasks +
                '}';
    }
}
